/**
 * Creating a sidebar enables you to:
 - create an ordered group of docs
 - render a sidebar for each doc of that group
 - provide next/previous navigation

 The sidebars can be generated from the filesystem, or explicitly defined here.

 Create as many sidebars as you want.
 */
const java = [
    {
        type: 'category',
        link: {type: 'doc', id: 'java/java基本程序设计结构/index'},
        label: 'java基本程序设计结构',
        items: [
            'java/java基本程序设计结构/数据类型/index',
            'java/java基本程序设计结构/变量与常量/index',
            'java/java基本程序设计结构/运算符/index',
            'java/java基本程序设计结构/字符串/index',
            'java/java基本程序设计结构/控制流程/index',
            'java/java基本程序设计结构/数组/index',
            'java/java基本程序设计结构/输入与输出/index',
        ]
    },
    'java/对象与类/index',
    {
        type: 'category',
        link: {type: 'doc', id: 'java/继承/index'},
        label: '继承',
        items: [
            'java/继承/类、超类和子类',
            'java/继承/继承层次结构',
            'java/继承/Object类',
        ]
    },
    'java/对象包装器与自动装箱/index',
    'java/抽象类/index',
    'java/枚举类/index',
    {
        type: 'category',
        link: {type: 'doc', id: 'java/反射/index'},
        label: '反射',
        items: [
            'java/反射/Class类',
            'java/反射/利用反射分析类',
            'java/反射/使用反射在运行时分析对象',
            'java/反射/使用反射编写泛型数组代码',
            'java/反射/调用任意方法和构造器',
            'java/反射/相关方法',
        ]
    },
    'java/接口/index',
    'java/lambda表达式/index',
    'java/内部类/index',
    'java/集合/index',
    'java/文件/index',
    {
        type: 'category',
        link: {type: 'doc', id: 'java/异常处理/index'},
        label: '异常处理',
        items: [
            'java/异常处理/声明异常'
        ]
    },
    {
        type: 'category',
        link: {type: 'doc', id: 'java/并发编程/index'},
        label: '并发编程',
        items: [
            'java/并发编程/创建和运行任务',
            'java/并发编程/终止长时间运行的任务',
            'java/并发编程/CompletableFuture',
        ]
    },

]

const jvm = [
    'JVM/index',
    {
        type: 'category',
        link: {type: 'doc', id: 'JVM/自动内存管理/index'},
        label: '自动内存管理',
        items: [
            'JVM/自动内存管理/Java内存管理与内存溢出异常',
            'JVM/自动内存管理/垃圾收集器',

        ]
    }
]
const sql = [
    {
        type: 'category',
        label: 'SQL基础',
        link: {type: 'doc', id: '数据库/SQL基础/index'},
        items: [
            '数据库/SQL基础/DDL/index',
            '数据库/SQL基础/检索数据/index',
            '数据库/SQL基础/数据过滤/index',
            '数据库/SQL基础/SQL函数/index',
            '数据库/SQL基础/聚合函数/index',
            '数据库/SQL基础/存储过程/index',
            '数据库/SQL基础/子查询/index'
        ]
    },
    {
        type: 'category',
        label: 'SQL优化',
        link: {type: 'doc', id: '数据库/SQL优化/index'},
        items: [
            '数据库/SQL优化/设计范式',
            '数据库/SQL优化/索引概览',
            '数据库/SQL优化/索引底层的数据结构',
            '数据库/SQL优化/索引的使用原则',
            '数据库/SQL优化/从数据页角度理解B+树查询',
            '数据库/SQL优化/理解SQL查询的成本',
            '数据库/SQL优化/锁',
            '数据库/SQL优化/MVCC',
            '数据库/SQL优化/查询优化器的工作原理',
        ]
    },
    {
        type: 'category',
        label: 'Redis',
        link: {type: 'doc', id: '数据库/Redis/index'},
        items: [
            '数据库/Redis/数据结构',
            '数据库/Redis/高性能IO模型',
            '数据库/Redis/AOF日志'
        ]
    },
    {
        type: 'category',
        label: 'mybatis',
        link: {type: 'doc', id: '数据库/mybatis/index'},
        items: [
            "数据库/mybatis/第一个MyBatis程序",
            "数据库/mybatis/CRUD",
            "数据库/mybatis/mapper",
            "数据库/mybatis/Map和模糊查询",
            "数据库/mybatis/配置解析",
            "数据库/mybatis/作用域和生命周期",
            "数据库/mybatis/resultMap",
            "数据库/mybatis/日志",
            "数据库/mybatis/分页",
            "数据库/mybatis/复杂查询",
            "数据库/mybatis/动态SQL",
            "数据库/mybatis/缓存",
        ]
    },
    {
        type: 'category',
        label: 'Redis实践',
        link: {type: 'doc', id: '数据库/Redis实践/index'},
        items: [
            '数据库/Redis/基本架构',
            '数据库/Redis/数据结构',
            '数据库/Redis/高性能IO模型',
            '数据库/Redis/AOF日志',
        ]
    },

]
const spring = [
    {
        type: 'category',
        label: 'Spring',
        link: {type: 'doc', id: 'spring/概述/index'},
        items: [
            'spring/概述/特性总览',
            'spring/概述/版本特性',
        ]
    },
    {
        type: 'category',
        label: '重新认识IOC',
        link: {type: 'doc', id: 'spring/重新认识IOC/index'},
        items: [
            'spring/重新认识IOC/IOC发展简介',
        ]
    },
    'spring/初始化Spring应用/index',
    'spring/编写Spring应用/index',
    'spring/开发web应用/index',
    'spring/Spring Data Jpa/index',
    'spring/创建REST服务/index',
    {
        type: 'category',
        label: 'Spring MVC',
        link: {type: 'doc', id: 'spring/SpringMVC/index'},
        items: []
    },
]
const designPattern = [
    'design-pattern/index',
    {
        type: 'category',
        label: '设计原则',
        link: {type: 'doc', id: 'design-pattern/设计原则/index'},
        items: ['design-pattern/设计原则/SRP']
    },
    {
        type: 'category',
        label: '设计模式-创建型',
        link: {type: 'doc', id: 'design-pattern/创建型/index'},
        items: [
            'design-pattern/创建型/单例模式/index',
            'design-pattern/创建型/工厂模式/index'
        ]
    },

    {
        type: 'category',
        label: '设计模式-结构型',
        link: {type: 'doc', id: 'design-pattern/结构型/index'},
        items: ['design-pattern/结构型/代理模式']
    },
    {
        type: 'category',
        label: '设计模式-行为型',
        link: {type: 'doc', id: 'design-pattern/行为型/index'},
        items: ['design-pattern/行为型/策略模式1']
    },
]
const concurrent = [
    {
        type: 'category',
        label: '理论篇',
        link: {type: 'doc', id: '并发编程/理论/index'},
        items: [
            '并发编程/理论/可见性、原子性和有序性问题',
            '并发编程/理论/Java内存模型',
            '并发编程/理论/互斥锁',
            '并发编程/理论/死锁',
            '并发编程/理论/等待通知机制',
            '并发编程/理论/安全性、活跃性以及性能问题',
            '并发编程/理论/Java线程的生命周期',
            '并发编程/理论/为什么局部变量是线程安全的',
        ]
    },
    {
        type: 'category',
        label: '并发工具类',
        link: {type: 'doc', id: '并发编程/并发工具类/index'},
        items: [
            '并发编程/并发工具类/Lock',
            '并发编程/并发工具类/Condition',
            '并发编程/并发工具类/Semaphore',
            '并发编程/并发工具类/ReadWriteLock',
            '并发编程/并发工具类/CountDownLatch和CyclicBarrier',
            '并发编程/并发工具类/并发容器',
            '并发编程/并发工具类/线程池',
            '并发编程/并发工具类/Future',
            '并发编程/并发工具类/CompletableFuture',
            '并发编程/并发工具类/Fork-Join',
        ]
    },
]
const mq = [
    'mq/index',
    'mq/如何选择消息队列',
    'mq/消息模型',
]
const tools = [
    'tools/单点登录/index',
    'tools/雪花算法/index',
    'tools/git/index',
    {
        type: 'category',
        label: 'gradle',
        link: {type: 'doc', id: 'tools/gradle/index'},
        items: [
            'tools/gradle/groovy语法',
            'tools/gradle/构建过程'
        ]
    },
    {
        type: 'category',
        label: 'GPT',
        link: {type: 'doc', id: 'tools/GPT/index'},
        items: [
            'tools/GPT/prompt',
            'tools/GPT/在边界内求最优解',
        ]
    },
    {
        type: 'category',
        label: '基于 Netty 实现聊天室',
        link: {type: 'doc', id: 'tools/基于 Netty 实现聊天室/index'},
        items: [
            'tools/基于 Netty 实现聊天室/Netty',
            'tools/基于 Netty 实现聊天室/阻塞和非阻塞同步异步',
            'tools/基于 Netty 实现聊天室/构建 Netty 服务器',
        ]
    },

    'tools/物流行业业务流程'
    // {
    //     type: 'category',
    //     label: 'xxlJob',
    //     link: {type: 'doc', id: 'tools/xxlJob/index'},
    //     items: [
    //     ]
    // }
]
// @ts-check

const distributed = [
    {
        type: 'category',
        label: '分布式场景常见解决方案',
        link: {type: 'doc', id: 'distributed/分布式解决方案/index'},
        items: [
            'distributed/分布式解决方案/分布式ID'
        ]
    },
    {
        type: 'category',
        label: '分布式任务调度',
        link: {type: 'doc', id: 'distributed/分布式任务调度/index'},
        items: []
    },
    {
        type: 'category',
        label: '分库分表',
        link: {type: 'doc', id: 'distributed/分库分表/index'},
        items: [
            'distributed/分库分表/高性能架构模式',
            'distributed/分库分表/ShardingSphere',
            'distributed/分库分表/MySQL主从同步',
        ]
    },
    {
        type: 'category',
        label: 'Spring Cloud 微服务',
        link: {type: 'doc', id: 'distributed/SpringCloud/index'},
        items: [
            {
                type: 'category',
                label: '服务间通信',
                link: {type: 'doc', id: 'distributed/SpringCloud/服务间通信/index'},
                items: [
                    'distributed/SpringCloud/服务间通信/服务治理',
                    'distributed/SpringCloud/服务间通信/Nacos集群环境搭建',
                    'distributed/SpringCloud/服务间通信/客户端集成Nacos',
                    'distributed/SpringCloud/服务间通信/负载均衡',
                    'distributed/SpringCloud/服务间通信/OpenFeign',
                ]
            },
            {
                type: 'category',
                label: '服务容错',
                link: {type: 'doc', id: 'distributed/SpringCloud/服务容错/index'},
                items: [
                    'distributed/SpringCloud/服务容错/什么是服务容错',
                ]
            },
        ]
    },

];
let kubernetes = [
    "kubernetes/index",
    {
        type: 'category',
        label: 'Docker',
        link: {type: 'doc', id: 'kubernetes/Docker/index'},
        items: [
            'kubernetes/Docker/Install',
            'kubernetes/Docker/容器的本质',
            'kubernetes/Docker/容器化的应用',
            'kubernetes/Docker/创建容器镜像',
            'kubernetes/Docker/镜像仓库',
        ]
    }
];
const coder = [
    "coder/index",
    "coder/Maven环境配置",
    "coder/技术架构及如何快速开发技巧",
    "coder/代码生成器原理",
    "coder/统一权限集成",
    "coder/状态模式",
]

/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
const sidebars = {
    java,
    jvm,
    sql,
    spring,
    distributed,
    designPattern,
    concurrent,
    mq,
    kubernetes,
    tools,
    coder,


};

module.exports = sidebars;
